package com.sa.ibiz.demo.demo.domain;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonProperty.Access;
import lombok.Data;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.cglib.beans.BeanGenerator;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.FieldFill;
import java.util.Map;
import java.util.HashMap;
import org.springframework.util.StringUtils;
import com.sa.ibiz.demo.ibizutil.security.AuthenticationUser;
import java.util.Date;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import java.util.UUID;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import org.springframework.cglib.beans.BeanCopier;
import com.sa.ibiz.demo.ibizutil.annotation.Dict;
import com.sa.ibiz.demo.ibizutil.domain.EntityBase;
import java.io.Serializable;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import java.math.BigInteger;
import com.sa.ibiz.demo.ibizutil.enums.FillMode;
import com.sa.ibiz.demo.ibizutil.enums.PredefinedType;
import com.sa.ibiz.demo.ibizutil.annotation.PreField;
import com.alibaba.fastjson.annotation.JSONField;

import com.sa.ibiz.demo.demo.domain.OrgSector;
import com.sa.ibiz.demo.demo.domain.OrgSecUserType;
import com.sa.ibiz.demo.demo.domain.OrgUser;
import com.sa.ibiz.demo.demo.domain.Org;

/**
 * 实体[OrgSecUser] 数据对象
 */
@TableName(value = "T_SRFORGSECUSER",resultMap = "OrgSecUserResultMap")
@JsonIgnoreProperties(ignoreUnknown = true)
@Data
public class OrgSecUser extends EntityBase implements Serializable{

    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private OrgSector orgsector;
    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private OrgSecUserType orgsecusertype;
    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private OrgUser orguser;
    @JSONField(serialize = false)
    @JsonIgnore
    @TableField(exist = false)//关系主表数据
    private Org org;
    @PreField(fill= FillMode.INSERT,preType = PredefinedType.CREATEDATE)
    private Timestamp createdate;
    @PreField(fill= FillMode.INSERT,preType = PredefinedType.CREATEMAN)
    @Dict(dictName = "WorkflowMob_SysOperatorCodeList")
    private String createman;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer defaultflag;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.ORGID)
    private String orgid;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.ORGNAME)
    private String orgname;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.ORGSECTORID)
    private String orgsectorid;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.ORGSECTORNAME)
    private String orgsectorname;
    @TableId(value= "orgsecuserid",type=IdType.UUID)//指定主键生成策略
    private String orgsecuserid;
    private String orgsecusername;
    private String orgsecusertypeid;
    private String orgsecusertypename;
    private String orguserid;
    private String orgusername;
    private String reserver;
    private String reserver10;
    private Integer reserver11;
    private Integer reserver12;
    private Integer reserver13;
    private Integer reserver14;
    private Double reserver15;
    private Double reserver16;
    private Double reserver17;
    private Double reserver18;
    private Timestamp reserver19;
    private String reserver2;
    private Timestamp reserver20;
    private Timestamp reserver21;
    private Timestamp reserver22;
    private String reserver23;
    private String reserver24;
    private String reserver25;
    private String reserver26;
    private String reserver27;
    private String reserver28;
    private String reserver29;
    private String reserver3;
    private String reserver30;
    private String reserver4;
    private String reserver5;
    private String reserver6;
    private String reserver7;
    private String reserver8;
    private String reserver9;
    private String titlename;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.UPDATEDATE)
    private Timestamp updatedate;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.UPDATEMAN)
    @Dict(dictName = "WorkflowMob_SysOperatorCodeList")
    private String updateman;
    private String userdata;
    private String userdata2;
    @Dict(dictName = "WorkflowMob_YesNoCodeList")
    private Integer validflag;
    /**
     *  设置属性值[建立时间]
     *  @param createdate
     */
    public void setCreatedate(Timestamp createdate){
        this.createdate = createdate;
        this.set("createdatedirtyflag",true);
    }
    /**
     *  获取属性值[建立时间]
     */
    public Timestamp getCreatedate(){
        return this.createdate;
    }
    /**
     *  重置属性值[建立时间]
     */
    public void resetCreatedate(){
        this.set("createdatedirtyflag",false);
        this.createdate = null;
    }
    /**
     *  设置属性值[建立人]
     *  @param createman
     */
    public void setCreateman(String createman){
        if(StringUtils.isEmpty(createman))
            createman=null;
        this.createman = createman;
        this.set("createmandirtyflag",true);
    }
    /**
     *  获取属性值[建立人]
     */
    public String getCreateman(){
        return this.createman;
    }
    /**
     *  重置属性值[建立人]
     */
    public void resetCreateman(){
        this.set("createmandirtyflag",false);
        this.createman = null;
    }
    /**
     *  设置属性值[默认关系]
     *  @param defaultflag
     */
    public void setDefaultflag(Integer defaultflag){
        this.defaultflag = defaultflag;
        this.set("defaultflagdirtyflag",true);
    }
    /**
     *  获取属性值[默认关系]
     */
    public Integer getDefaultflag(){
        return this.defaultflag;
    }
    /**
     *  重置属性值[默认关系]
     */
    public void resetDefaultflag(){
        this.set("defaultflagdirtyflag",false);
        this.defaultflag = null;
    }
    /**
     *  设置属性值[组织机构]
     *  @param orgid
     */
    public void setOrgid(String orgid){
        if(StringUtils.isEmpty(orgid))
            orgid=null;
        this.orgid = orgid;
        this.set("orgiddirtyflag",true);
    }
    /**
     *  获取属性值[组织机构]
     */
    public String getOrgid(){
        return this.orgid;
    }
    /**
     *  重置属性值[组织机构]
     */
    public void resetOrgid(){
        this.set("orgiddirtyflag",false);
        this.orgid = null;
    }
    /**
     *  设置属性值[组织机构]
     *  @param orgname
     */
    public void setOrgname(String orgname){
        if(StringUtils.isEmpty(orgname))
            orgname=null;
        this.orgname = orgname;
        this.set("orgnamedirtyflag",true);
    }
    /**
     *  获取属性值[组织机构]
     */
    public String getOrgname(){
        //填充物理化的外键值附加数据
        if(StringUtils.isEmpty(this.orgname)&&(!StringUtils.isEmpty(this.getOrgid())) && this.getOrg()!=null)
        {
            this.orgname = this.getOrg().getOrgname();
            this.set("orgnamedirtyflag",true);
        }
        return this.orgname;
    }
    /**
     *  重置属性值[组织机构]
     */
    public void resetOrgname(){
        this.set("orgnamedirtyflag",false);
        this.orgname = null;
    }
    /**
     *  设置属性值[组织部门]
     *  @param orgsectorid
     */
    public void setOrgsectorid(String orgsectorid){
        if(StringUtils.isEmpty(orgsectorid))
            orgsectorid=null;
        this.orgsectorid = orgsectorid;
        this.set("orgsectoriddirtyflag",true);
    }
    /**
     *  获取属性值[组织部门]
     */
    public String getOrgsectorid(){
        return this.orgsectorid;
    }
    /**
     *  重置属性值[组织部门]
     */
    public void resetOrgsectorid(){
        this.set("orgsectoriddirtyflag",false);
        this.orgsectorid = null;
    }
    /**
     *  设置属性值[组织部门]
     *  @param orgsectorname
     */
    public void setOrgsectorname(String orgsectorname){
        if(StringUtils.isEmpty(orgsectorname))
            orgsectorname=null;
        this.orgsectorname = orgsectorname;
        this.set("orgsectornamedirtyflag",true);
    }
    /**
     *  获取属性值[组织部门]
     */
    public String getOrgsectorname(){
        //填充物理化的外键值附加数据
        if(StringUtils.isEmpty(this.orgsectorname)&&(!StringUtils.isEmpty(this.getOrgsectorid())) && this.getOrgsector()!=null)
        {
            this.orgsectorname = this.getOrgsector().getOrgsectorname();
            this.set("orgsectornamedirtyflag",true);
        }
        return this.orgsectorname;
    }
    /**
     *  重置属性值[组织部门]
     */
    public void resetOrgsectorname(){
        this.set("orgsectornamedirtyflag",false);
        this.orgsectorname = null;
    }
    /**
     *  设置属性值[组织部门人员标识]
     *  @param orgsecuserid
     */
    public void setOrgsecuserid(String orgsecuserid){
        if(StringUtils.isEmpty(orgsecuserid))
            orgsecuserid=null;
        this.orgsecuserid = orgsecuserid;
        this.set("orgsecuseriddirtyflag",true);
    }
    /**
     *  获取属性值[组织部门人员标识]
     */
    public String getOrgsecuserid(){
        return this.orgsecuserid;
    }
    /**
     *  重置属性值[组织部门人员标识]
     */
    public void resetOrgsecuserid(){
        this.set("orgsecuseriddirtyflag",false);
        this.orgsecuserid = null;
    }
    /**
     *  设置属性值[组织部门人员名称]
     *  @param orgsecusername
     */
    public void setOrgsecusername(String orgsecusername){
        if(StringUtils.isEmpty(orgsecusername))
            orgsecusername=null;
        this.orgsecusername = orgsecusername;
        this.set("orgsecusernamedirtyflag",true);
    }
    /**
     *  获取属性值[组织部门人员名称]
     */
    public String getOrgsecusername(){
        return this.orgsecusername;
    }
    /**
     *  重置属性值[组织部门人员名称]
     */
    public void resetOrgsecusername(){
        this.set("orgsecusernamedirtyflag",false);
        this.orgsecusername = null;
    }
    /**
     *  设置属性值[部门人员关系]
     *  @param orgsecusertypeid
     */
    public void setOrgsecusertypeid(String orgsecusertypeid){
        if(StringUtils.isEmpty(orgsecusertypeid))
            orgsecusertypeid=null;
        this.orgsecusertypeid = orgsecusertypeid;
        this.set("orgsecusertypeiddirtyflag",true);
    }
    /**
     *  获取属性值[部门人员关系]
     */
    public String getOrgsecusertypeid(){
        return this.orgsecusertypeid;
    }
    /**
     *  重置属性值[部门人员关系]
     */
    public void resetOrgsecusertypeid(){
        this.set("orgsecusertypeiddirtyflag",false);
        this.orgsecusertypeid = null;
    }
    /**
     *  设置属性值[部门人员关系]
     *  @param orgsecusertypename
     */
    public void setOrgsecusertypename(String orgsecusertypename){
        if(StringUtils.isEmpty(orgsecusertypename))
            orgsecusertypename=null;
        this.orgsecusertypename = orgsecusertypename;
        this.set("orgsecusertypenamedirtyflag",true);
    }
    /**
     *  获取属性值[部门人员关系]
     */
    public String getOrgsecusertypename(){
        //填充物理化的外键值附加数据
        if(StringUtils.isEmpty(this.orgsecusertypename)&&(!StringUtils.isEmpty(this.getOrgsecusertypeid())) && this.getOrgsecusertype()!=null)
        {
            this.orgsecusertypename = this.getOrgsecusertype().getOrgsecusertypename();
            this.set("orgsecusertypenamedirtyflag",true);
        }
        return this.orgsecusertypename;
    }
    /**
     *  重置属性值[部门人员关系]
     */
    public void resetOrgsecusertypename(){
        this.set("orgsecusertypenamedirtyflag",false);
        this.orgsecusertypename = null;
    }
    /**
     *  设置属性值[组织人员]
     *  @param orguserid
     */
    public void setOrguserid(String orguserid){
        if(StringUtils.isEmpty(orguserid))
            orguserid=null;
        this.orguserid = orguserid;
        this.set("orguseriddirtyflag",true);
    }
    /**
     *  获取属性值[组织人员]
     */
    public String getOrguserid(){
        return this.orguserid;
    }
    /**
     *  重置属性值[组织人员]
     */
    public void resetOrguserid(){
        this.set("orguseriddirtyflag",false);
        this.orguserid = null;
    }
    /**
     *  设置属性值[组织人员]
     *  @param orgusername
     */
    public void setOrgusername(String orgusername){
        if(StringUtils.isEmpty(orgusername))
            orgusername=null;
        this.orgusername = orgusername;
        this.set("orgusernamedirtyflag",true);
    }
    /**
     *  获取属性值[组织人员]
     */
    public String getOrgusername(){
        //填充物理化的外键值附加数据
        if(StringUtils.isEmpty(this.orgusername)&&(!StringUtils.isEmpty(this.getOrguserid())) && this.getOrguser()!=null)
        {
            this.orgusername = this.getOrguser().getOrgusername();
            this.set("orgusernamedirtyflag",true);
        }
        return this.orgusername;
    }
    /**
     *  重置属性值[组织人员]
     */
    public void resetOrgusername(){
        this.set("orgusernamedirtyflag",false);
        this.orgusername = null;
    }
    /**
     *  设置属性值[保留字段]
     *  @param reserver
     */
    public void setReserver(String reserver){
        if(StringUtils.isEmpty(reserver))
            reserver=null;
        this.reserver = reserver;
        this.set("reserverdirtyflag",true);
    }
    /**
     *  获取属性值[保留字段]
     */
    public String getReserver(){
        return this.reserver;
    }
    /**
     *  重置属性值[保留字段]
     */
    public void resetReserver(){
        this.set("reserverdirtyflag",false);
        this.reserver = null;
    }
    /**
     *  设置属性值[保留字段10]
     *  @param reserver10
     */
    public void setReserver10(String reserver10){
        if(StringUtils.isEmpty(reserver10))
            reserver10=null;
        this.reserver10 = reserver10;
        this.set("reserver10dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段10]
     */
    public String getReserver10(){
        return this.reserver10;
    }
    /**
     *  重置属性值[保留字段10]
     */
    public void resetReserver10(){
        this.set("reserver10dirtyflag",false);
        this.reserver10 = null;
    }
    /**
     *  设置属性值[保留字段11]
     *  @param reserver11
     */
    public void setReserver11(Integer reserver11){
        this.reserver11 = reserver11;
        this.set("reserver11dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段11]
     */
    public Integer getReserver11(){
        return this.reserver11;
    }
    /**
     *  重置属性值[保留字段11]
     */
    public void resetReserver11(){
        this.set("reserver11dirtyflag",false);
        this.reserver11 = null;
    }
    /**
     *  设置属性值[保留字段12]
     *  @param reserver12
     */
    public void setReserver12(Integer reserver12){
        this.reserver12 = reserver12;
        this.set("reserver12dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段12]
     */
    public Integer getReserver12(){
        return this.reserver12;
    }
    /**
     *  重置属性值[保留字段12]
     */
    public void resetReserver12(){
        this.set("reserver12dirtyflag",false);
        this.reserver12 = null;
    }
    /**
     *  设置属性值[保留字段13]
     *  @param reserver13
     */
    public void setReserver13(Integer reserver13){
        this.reserver13 = reserver13;
        this.set("reserver13dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段13]
     */
    public Integer getReserver13(){
        return this.reserver13;
    }
    /**
     *  重置属性值[保留字段13]
     */
    public void resetReserver13(){
        this.set("reserver13dirtyflag",false);
        this.reserver13 = null;
    }
    /**
     *  设置属性值[保留字段14]
     *  @param reserver14
     */
    public void setReserver14(Integer reserver14){
        this.reserver14 = reserver14;
        this.set("reserver14dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段14]
     */
    public Integer getReserver14(){
        return this.reserver14;
    }
    /**
     *  重置属性值[保留字段14]
     */
    public void resetReserver14(){
        this.set("reserver14dirtyflag",false);
        this.reserver14 = null;
    }
    /**
     *  设置属性值[保留字段15]
     *  @param reserver15
     */
    public void setReserver15(Double reserver15){
        this.reserver15 = reserver15;
        this.set("reserver15dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段15]
     */
    public Double getReserver15(){
        return this.reserver15;
    }
    /**
     *  重置属性值[保留字段15]
     */
    public void resetReserver15(){
        this.set("reserver15dirtyflag",false);
        this.reserver15 = null;
    }
    /**
     *  设置属性值[保留字段16]
     *  @param reserver16
     */
    public void setReserver16(Double reserver16){
        this.reserver16 = reserver16;
        this.set("reserver16dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段16]
     */
    public Double getReserver16(){
        return this.reserver16;
    }
    /**
     *  重置属性值[保留字段16]
     */
    public void resetReserver16(){
        this.set("reserver16dirtyflag",false);
        this.reserver16 = null;
    }
    /**
     *  设置属性值[保留字段17]
     *  @param reserver17
     */
    public void setReserver17(Double reserver17){
        this.reserver17 = reserver17;
        this.set("reserver17dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段17]
     */
    public Double getReserver17(){
        return this.reserver17;
    }
    /**
     *  重置属性值[保留字段17]
     */
    public void resetReserver17(){
        this.set("reserver17dirtyflag",false);
        this.reserver17 = null;
    }
    /**
     *  设置属性值[保留字段18]
     *  @param reserver18
     */
    public void setReserver18(Double reserver18){
        this.reserver18 = reserver18;
        this.set("reserver18dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段18]
     */
    public Double getReserver18(){
        return this.reserver18;
    }
    /**
     *  重置属性值[保留字段18]
     */
    public void resetReserver18(){
        this.set("reserver18dirtyflag",false);
        this.reserver18 = null;
    }
    /**
     *  设置属性值[保留字段19]
     *  @param reserver19
     */
    public void setReserver19(Timestamp reserver19){
        this.reserver19 = reserver19;
        this.set("reserver19dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段19]
     */
    public Timestamp getReserver19(){
        return this.reserver19;
    }
    /**
     *  重置属性值[保留字段19]
     */
    public void resetReserver19(){
        this.set("reserver19dirtyflag",false);
        this.reserver19 = null;
    }
    /**
     *  设置属性值[保留字段2]
     *  @param reserver2
     */
    public void setReserver2(String reserver2){
        if(StringUtils.isEmpty(reserver2))
            reserver2=null;
        this.reserver2 = reserver2;
        this.set("reserver2dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段2]
     */
    public String getReserver2(){
        return this.reserver2;
    }
    /**
     *  重置属性值[保留字段2]
     */
    public void resetReserver2(){
        this.set("reserver2dirtyflag",false);
        this.reserver2 = null;
    }
    /**
     *  设置属性值[保留字段20]
     *  @param reserver20
     */
    public void setReserver20(Timestamp reserver20){
        this.reserver20 = reserver20;
        this.set("reserver20dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段20]
     */
    public Timestamp getReserver20(){
        return this.reserver20;
    }
    /**
     *  重置属性值[保留字段20]
     */
    public void resetReserver20(){
        this.set("reserver20dirtyflag",false);
        this.reserver20 = null;
    }
    /**
     *  设置属性值[保留字段21]
     *  @param reserver21
     */
    public void setReserver21(Timestamp reserver21){
        this.reserver21 = reserver21;
        this.set("reserver21dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段21]
     */
    public Timestamp getReserver21(){
        return this.reserver21;
    }
    /**
     *  重置属性值[保留字段21]
     */
    public void resetReserver21(){
        this.set("reserver21dirtyflag",false);
        this.reserver21 = null;
    }
    /**
     *  设置属性值[保留字段22]
     *  @param reserver22
     */
    public void setReserver22(Timestamp reserver22){
        this.reserver22 = reserver22;
        this.set("reserver22dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段22]
     */
    public Timestamp getReserver22(){
        return this.reserver22;
    }
    /**
     *  重置属性值[保留字段22]
     */
    public void resetReserver22(){
        this.set("reserver22dirtyflag",false);
        this.reserver22 = null;
    }
    /**
     *  设置属性值[保留字段23]
     *  @param reserver23
     */
    public void setReserver23(String reserver23){
        if(StringUtils.isEmpty(reserver23))
            reserver23=null;
        this.reserver23 = reserver23;
        this.set("reserver23dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段23]
     */
    public String getReserver23(){
        return this.reserver23;
    }
    /**
     *  重置属性值[保留字段23]
     */
    public void resetReserver23(){
        this.set("reserver23dirtyflag",false);
        this.reserver23 = null;
    }
    /**
     *  设置属性值[保留字段24]
     *  @param reserver24
     */
    public void setReserver24(String reserver24){
        if(StringUtils.isEmpty(reserver24))
            reserver24=null;
        this.reserver24 = reserver24;
        this.set("reserver24dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段24]
     */
    public String getReserver24(){
        return this.reserver24;
    }
    /**
     *  重置属性值[保留字段24]
     */
    public void resetReserver24(){
        this.set("reserver24dirtyflag",false);
        this.reserver24 = null;
    }
    /**
     *  设置属性值[保留字段25]
     *  @param reserver25
     */
    public void setReserver25(String reserver25){
        if(StringUtils.isEmpty(reserver25))
            reserver25=null;
        this.reserver25 = reserver25;
        this.set("reserver25dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段25]
     */
    public String getReserver25(){
        return this.reserver25;
    }
    /**
     *  重置属性值[保留字段25]
     */
    public void resetReserver25(){
        this.set("reserver25dirtyflag",false);
        this.reserver25 = null;
    }
    /**
     *  设置属性值[保留字段26]
     *  @param reserver26
     */
    public void setReserver26(String reserver26){
        if(StringUtils.isEmpty(reserver26))
            reserver26=null;
        this.reserver26 = reserver26;
        this.set("reserver26dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段26]
     */
    public String getReserver26(){
        return this.reserver26;
    }
    /**
     *  重置属性值[保留字段26]
     */
    public void resetReserver26(){
        this.set("reserver26dirtyflag",false);
        this.reserver26 = null;
    }
    /**
     *  设置属性值[保留字段27]
     *  @param reserver27
     */
    public void setReserver27(String reserver27){
        if(StringUtils.isEmpty(reserver27))
            reserver27=null;
        this.reserver27 = reserver27;
        this.set("reserver27dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段27]
     */
    public String getReserver27(){
        return this.reserver27;
    }
    /**
     *  重置属性值[保留字段27]
     */
    public void resetReserver27(){
        this.set("reserver27dirtyflag",false);
        this.reserver27 = null;
    }
    /**
     *  设置属性值[保留字段28]
     *  @param reserver28
     */
    public void setReserver28(String reserver28){
        if(StringUtils.isEmpty(reserver28))
            reserver28=null;
        this.reserver28 = reserver28;
        this.set("reserver28dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段28]
     */
    public String getReserver28(){
        return this.reserver28;
    }
    /**
     *  重置属性值[保留字段28]
     */
    public void resetReserver28(){
        this.set("reserver28dirtyflag",false);
        this.reserver28 = null;
    }
    /**
     *  设置属性值[保留字段29]
     *  @param reserver29
     */
    public void setReserver29(String reserver29){
        if(StringUtils.isEmpty(reserver29))
            reserver29=null;
        this.reserver29 = reserver29;
        this.set("reserver29dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段29]
     */
    public String getReserver29(){
        return this.reserver29;
    }
    /**
     *  重置属性值[保留字段29]
     */
    public void resetReserver29(){
        this.set("reserver29dirtyflag",false);
        this.reserver29 = null;
    }
    /**
     *  设置属性值[保留字段3]
     *  @param reserver3
     */
    public void setReserver3(String reserver3){
        if(StringUtils.isEmpty(reserver3))
            reserver3=null;
        this.reserver3 = reserver3;
        this.set("reserver3dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段3]
     */
    public String getReserver3(){
        return this.reserver3;
    }
    /**
     *  重置属性值[保留字段3]
     */
    public void resetReserver3(){
        this.set("reserver3dirtyflag",false);
        this.reserver3 = null;
    }
    /**
     *  设置属性值[保留字段30]
     *  @param reserver30
     */
    public void setReserver30(String reserver30){
        if(StringUtils.isEmpty(reserver30))
            reserver30=null;
        this.reserver30 = reserver30;
        this.set("reserver30dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段30]
     */
    public String getReserver30(){
        return this.reserver30;
    }
    /**
     *  重置属性值[保留字段30]
     */
    public void resetReserver30(){
        this.set("reserver30dirtyflag",false);
        this.reserver30 = null;
    }
    /**
     *  设置属性值[保留字段4]
     *  @param reserver4
     */
    public void setReserver4(String reserver4){
        if(StringUtils.isEmpty(reserver4))
            reserver4=null;
        this.reserver4 = reserver4;
        this.set("reserver4dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段4]
     */
    public String getReserver4(){
        return this.reserver4;
    }
    /**
     *  重置属性值[保留字段4]
     */
    public void resetReserver4(){
        this.set("reserver4dirtyflag",false);
        this.reserver4 = null;
    }
    /**
     *  设置属性值[保留字段5]
     *  @param reserver5
     */
    public void setReserver5(String reserver5){
        if(StringUtils.isEmpty(reserver5))
            reserver5=null;
        this.reserver5 = reserver5;
        this.set("reserver5dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段5]
     */
    public String getReserver5(){
        return this.reserver5;
    }
    /**
     *  重置属性值[保留字段5]
     */
    public void resetReserver5(){
        this.set("reserver5dirtyflag",false);
        this.reserver5 = null;
    }
    /**
     *  设置属性值[保留字段6]
     *  @param reserver6
     */
    public void setReserver6(String reserver6){
        if(StringUtils.isEmpty(reserver6))
            reserver6=null;
        this.reserver6 = reserver6;
        this.set("reserver6dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段6]
     */
    public String getReserver6(){
        return this.reserver6;
    }
    /**
     *  重置属性值[保留字段6]
     */
    public void resetReserver6(){
        this.set("reserver6dirtyflag",false);
        this.reserver6 = null;
    }
    /**
     *  设置属性值[保留字段7]
     *  @param reserver7
     */
    public void setReserver7(String reserver7){
        if(StringUtils.isEmpty(reserver7))
            reserver7=null;
        this.reserver7 = reserver7;
        this.set("reserver7dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段7]
     */
    public String getReserver7(){
        return this.reserver7;
    }
    /**
     *  重置属性值[保留字段7]
     */
    public void resetReserver7(){
        this.set("reserver7dirtyflag",false);
        this.reserver7 = null;
    }
    /**
     *  设置属性值[保留字段8]
     *  @param reserver8
     */
    public void setReserver8(String reserver8){
        if(StringUtils.isEmpty(reserver8))
            reserver8=null;
        this.reserver8 = reserver8;
        this.set("reserver8dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段8]
     */
    public String getReserver8(){
        return this.reserver8;
    }
    /**
     *  重置属性值[保留字段8]
     */
    public void resetReserver8(){
        this.set("reserver8dirtyflag",false);
        this.reserver8 = null;
    }
    /**
     *  设置属性值[保留字段9]
     *  @param reserver9
     */
    public void setReserver9(String reserver9){
        if(StringUtils.isEmpty(reserver9))
            reserver9=null;
        this.reserver9 = reserver9;
        this.set("reserver9dirtyflag",true);
    }
    /**
     *  获取属性值[保留字段9]
     */
    public String getReserver9(){
        return this.reserver9;
    }
    /**
     *  重置属性值[保留字段9]
     */
    public void resetReserver9(){
        this.set("reserver9dirtyflag",false);
        this.reserver9 = null;
    }
    /**
     *  设置属性值[头衔名称]
     *  @param titlename
     */
    public void setTitlename(String titlename){
        if(StringUtils.isEmpty(titlename))
            titlename=null;
        this.titlename = titlename;
        this.set("titlenamedirtyflag",true);
    }
    /**
     *  获取属性值[头衔名称]
     */
    public String getTitlename(){
        return this.titlename;
    }
    /**
     *  重置属性值[头衔名称]
     */
    public void resetTitlename(){
        this.set("titlenamedirtyflag",false);
        this.titlename = null;
    }
    /**
     *  设置属性值[更新时间]
     *  @param updatedate
     */
    public void setUpdatedate(Timestamp updatedate){
        this.updatedate = updatedate;
        this.set("updatedatedirtyflag",true);
    }
    /**
     *  获取属性值[更新时间]
     */
    public Timestamp getUpdatedate(){
        return this.updatedate;
    }
    /**
     *  重置属性值[更新时间]
     */
    public void resetUpdatedate(){
        this.set("updatedatedirtyflag",false);
        this.updatedate = null;
    }
    /**
     *  设置属性值[更新人]
     *  @param updateman
     */
    public void setUpdateman(String updateman){
        if(StringUtils.isEmpty(updateman))
            updateman=null;
        this.updateman = updateman;
        this.set("updatemandirtyflag",true);
    }
    /**
     *  获取属性值[更新人]
     */
    public String getUpdateman(){
        return this.updateman;
    }
    /**
     *  重置属性值[更新人]
     */
    public void resetUpdateman(){
        this.set("updatemandirtyflag",false);
        this.updateman = null;
    }
    /**
     *  设置属性值[用户数据]
     *  @param userdata
     */
    public void setUserdata(String userdata){
        if(StringUtils.isEmpty(userdata))
            userdata=null;
        this.userdata = userdata;
        this.set("userdatadirtyflag",true);
    }
    /**
     *  获取属性值[用户数据]
     */
    public String getUserdata(){
        return this.userdata;
    }
    /**
     *  重置属性值[用户数据]
     */
    public void resetUserdata(){
        this.set("userdatadirtyflag",false);
        this.userdata = null;
    }
    /**
     *  设置属性值[用户数据2]
     *  @param userdata2
     */
    public void setUserdata2(String userdata2){
        if(StringUtils.isEmpty(userdata2))
            userdata2=null;
        this.userdata2 = userdata2;
        this.set("userdata2dirtyflag",true);
    }
    /**
     *  获取属性值[用户数据2]
     */
    public String getUserdata2(){
        return this.userdata2;
    }
    /**
     *  重置属性值[用户数据2]
     */
    public void resetUserdata2(){
        this.set("userdata2dirtyflag",false);
        this.userdata2 = null;
    }
    /**
     *  设置属性值[启用标志]
     *  @param validflag
     */
    public void setValidflag(Integer validflag){
        this.validflag = validflag;
        this.set("validflagdirtyflag",true);
    }
    /**
     *  获取属性值[启用标志]
     */
    public Integer getValidflag(){
        return this.validflag;
    }
    /**
     *  重置属性值[启用标志]
     */
    public void resetValidflag(){
        this.set("validflagdirtyflag",false);
        this.validflag = null;
    }
     /**
     *  获取主实体关联数据[OrgSector]
     */
    public OrgSector getOrgsector() {
        return orgsector;
    }
    /**
     *  设置主实体关联数据[OrgSector]
     */
    public void setOrgsector(OrgSector orgsector) {
        this.orgsector = orgsector;
    }

     /**
     *  获取主实体关联数据[OrgSecUserType]
     */
    public OrgSecUserType getOrgsecusertype() {
        return orgsecusertype;
    }
    /**
     *  设置主实体关联数据[OrgSecUserType]
     */
    public void setOrgsecusertype(OrgSecUserType orgsecusertype) {
        this.orgsecusertype = orgsecusertype;
    }

     /**
     *  获取主实体关联数据[OrgUser]
     */
    public OrgUser getOrguser() {
        return orguser;
    }
    /**
     *  设置主实体关联数据[OrgUser]
     */
    public void setOrguser(OrgUser orguser) {
        this.orguser = orguser;
    }

     /**
     *  获取主实体关联数据[Org]
     */
    public Org getOrg() {
        return org;
    }
    /**
     *  设置主实体关联数据[Org]
     */
    public void setOrg(Org org) {
        this.org = org;
    }

    /**
     * 重置当前数据对象属性值
     */
    public  void reset(){
        resetCreatedate();
        resetCreateman();
        resetDefaultflag();
        resetOrgid();
        resetOrgname();
        resetOrgsectorid();
        resetOrgsectorname();
        resetOrgsecuserid();
        resetOrgsecusername();
        resetOrgsecusertypeid();
        resetOrgsecusertypename();
        resetOrguserid();
        resetOrgusername();
        resetReserver();
        resetReserver10();
        resetReserver11();
        resetReserver12();
        resetReserver13();
        resetReserver14();
        resetReserver15();
        resetReserver16();
        resetReserver17();
        resetReserver18();
        resetReserver19();
        resetReserver2();
        resetReserver20();
        resetReserver21();
        resetReserver22();
        resetReserver23();
        resetReserver24();
        resetReserver25();
        resetReserver26();
        resetReserver27();
        resetReserver28();
        resetReserver29();
        resetReserver3();
        resetReserver30();
        resetReserver4();
        resetReserver5();
        resetReserver6();
        resetReserver7();
        resetReserver8();
        resetReserver9();
        resetTitlename();
        resetUpdatedate();
        resetUpdateman();
        resetUserdata();
        resetUserdata2();
        resetValidflag();
    }
     /**
     * 获取数据主键（普通主键与联合主键）
     * @return
     */
    @JsonIgnore
    public Serializable getDefaultPrimaryKey()
    {
    	//联合主键
        String primaryKey ="";
        primaryKey+=this.getOrgsectorid();
        primaryKey+="||";
        primaryKey+=this.getOrguserid();
        return  DigestUtils.md5DigestAsHex(primaryKey.getBytes());
    }
     /**
     * 复制当前对象数据到目标对象(粘贴重置)
     *
     * @throws Exception
     */
    public OrgSecUser copyTo(OrgSecUser targetEntity)
	{
		BeanCopier copier=BeanCopier.create(OrgSecUser.class, OrgSecUser.class, false);
		copier.copy(this, targetEntity, null);
        targetEntity.resetOrgsecuserid();
		return targetEntity;
	}
}